home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 5 / Amiga Tools 5.iso / tools / developer-tools / andere sprachen / perl5 / perl5.002 / perly.c.diff < prev    next >
Encoding:
Text File  |  1996-02-15  |  11.2 KB  |  424 lines
  1. *** perly.c.orig    Wed Feb 14 15:29:04 1996
  2. --- perly.c    Wed Feb 14 15:29:05 1996
  3. ***************
  4. *** 12,82 ****
  5.       deprecate("\"do\" to call subroutines");
  6.   }
  7.   
  8. - #line 29 "perly.y"
  9. - typedef union {
  10. -     I32    ival;
  11. -     char *pval;
  12. -     OP *opval;
  13. -     GV *gvval;
  14. - } YYSTYPE;
  15. - #line 23 "y.tab.c"
  16. - #define WORD 257
  17. - #define METHOD 258
  18. - #define FUNCMETH 259
  19. - #define THING 260
  20. - #define PMFUNC 261
  21. - #define PRIVATEREF 262
  22. - #define FUNC0SUB 263
  23. - #define UNIOPSUB 264
  24. - #define LSTOPSUB 265
  25. - #define LABEL 266
  26. - #define FORMAT 267
  27. - #define SUB 268
  28. - #define ANONSUB 269
  29. - #define PACKAGE 270
  30. - #define USE 271
  31. - #define WHILE 272
  32. - #define UNTIL 273
  33. - #define IF 274
  34. - #define UNLESS 275
  35. - #define ELSE 276
  36. - #define ELSIF 277
  37. - #define CONTINUE 278
  38. - #define FOR 279
  39. - #define LOOPEX 280
  40. - #define DOTDOT 281
  41. - #define FUNC0 282
  42. - #define FUNC1 283
  43. - #define FUNC 284
  44. - #define RELOP 285
  45. - #define EQOP 286
  46. - #define MULOP 287
  47. - #define ADDOP 288
  48. - #define DOLSHARP 289
  49. - #define DO 290
  50. - #define LOCAL 291
  51. - #define HASHBRACK 292
  52. - #define NOAMP 293
  53. - #define OROP 294
  54. - #define ANDOP 295
  55. - #define NOTOP 296
  56. - #define LSTOP 297
  57. - #define ASSIGNOP 298
  58. - #define OROR 299
  59. - #define ANDAND 300
  60. - #define BITOROP 301
  61. - #define BITANDOP 302
  62. - #define UNIOP 303
  63. - #define SHIFTOP 304
  64. - #define MATCHOP 305
  65. - #define UMINUS 306
  66. - #define REFGEN 307
  67. - #define POWOP 308
  68. - #define PREINC 309
  69. - #define PREDEC 310
  70. - #define POSTINC 311
  71. - #define POSTDEC 312
  72. - #define ARROW 313
  73.   #define YYERRCODE 256
  74.   short yylhs[] = {                                        -1,
  75.      31,    0,    5,    3,    6,    6,    6,    7,    7,    7,
  76. --- 12,17 ----
  77. ***************
  78. *** 1381,1393 ****
  79.   int yynerrs;
  80.   int yyerrflag;
  81.   int yychar;
  82. - short *yyssp;
  83. - YYSTYPE *yyvsp;
  84.   YYSTYPE yyval;
  85.   YYSTYPE yylval;
  86. - short yyss[YYSTACKSIZE];
  87. - YYSTYPE yyvs[YYSTACKSIZE];
  88. - #define yystacksize YYSTACKSIZE
  89.   #line 571 "perly.y"
  90.    /* PROGRAM */
  91.   #line 1394 "y.tab.c"
  92. --- 1316,1323 ----
  93. ***************
  94. *** 1394,1407 ****
  95. --- 1324,1382 ----
  96.   #define YYABORT goto yyabort
  97.   #define YYACCEPT goto yyaccept
  98.   #define YYERROR goto yyerrlab
  99. + 
  100. + struct ysv {
  101. +     short* yyss;
  102. +     YYSTYPE* yyvs;
  103. +     int oldyydebug;
  104. +     int oldyynerrs;
  105. +     int oldyyerrflag;
  106. +     int oldyychar;
  107. +     YYSTYPE oldyyval;
  108. +     YYSTYPE oldyylval;
  109. + };
  110. + 
  111. + void
  112. + yydestruct(ptr)
  113. + void* ptr;
  114. + {
  115. +     struct ysv* ysave = (struct ysv*)ptr;
  116. +     if (ysave->yyss) Safefree(ysave->yyss);
  117. +     if (ysave->yyvs) Safefree(ysave->yyvs);
  118. +     yydebug    = ysave->oldyydebug;
  119. +     yynerrs    = ysave->oldyynerrs;
  120. +     yyerrflag    = ysave->oldyyerrflag;
  121. +     yychar    = ysave->oldyychar;
  122. +     yyval    = ysave->oldyyval;
  123. +     yylval    = ysave->oldyylval;
  124. +     Safefree(ysave);
  125. + }
  126. + 
  127.   int
  128.   yyparse()
  129.   {
  130.       register int yym, yyn, yystate;
  131. +     register short *yyssp;
  132. +     register YYSTYPE *yyvsp;
  133. +     short* yyss;
  134. +     YYSTYPE* yyvs;
  135. +     unsigned yystacksize = YYSTACKSIZE;
  136. +     int retval = 0;
  137.   #if YYDEBUG
  138.       register char *yys;
  139.       extern char *getenv();
  140. + #endif
  141.   
  142. +     struct ysv *ysave = (struct ysv*)safemalloc(sizeof(struct ysv));
  143. +     SAVEDESTRUCTOR(yydestruct, ysave);
  144. +     ysave->oldyydebug    = yydebug;
  145. +     ysave->oldyynerrs    = yynerrs;
  146. +     ysave->oldyyerrflag    = yyerrflag;
  147. +     ysave->oldyychar    = yychar;
  148. +     ysave->oldyyval    = yyval;
  149. +     ysave->oldyylval    = yylval;
  150. + 
  151. + #if YYDEBUG
  152.       if (yys = getenv("YYDEBUG"))
  153.       {
  154.           yyn = *yys;
  155. ***************
  156. *** 1414,1419 ****
  157. --- 1389,1402 ----
  158.       yyerrflag = 0;
  159.       yychar = (-1);
  160.   
  161. +     /*
  162. +     ** Initialize private stacks (yyparse may be called from an action)
  163. +     */
  164. +     ysave->yyss = yyss = (short*)safemalloc(yystacksize*sizeof(short));
  165. +     ysave->yyvs = yyvs = (YYSTYPE*)safemalloc(yystacksize*sizeof(YYSTYPE));
  166. +     if (!yyvs || !yyss)
  167. +     goto yyoverflow;
  168. + 
  169.       yyssp = yyss;
  170.       yyvsp = yyvs;
  171.       *yyssp = yystate = 0;
  172. ***************
  173. *** 1429,1435 ****
  174.               yys = 0;
  175.               if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  176.               if (!yys) yys = "illegal-symbol";
  177. !             printf("yydebug: state %d, reading %d (%s)\n", yystate,
  178.                       yychar, yys);
  179.           }
  180.   #endif
  181. --- 1412,1418 ----
  182.               yys = 0;
  183.               if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  184.               if (!yys) yys = "illegal-symbol";
  185. !             fprintf(stderr, "yydebug: state %d, reading %d (%s)\n", yystate,
  186.                       yychar, yys);
  187.           }
  188.   #endif
  189. ***************
  190. *** 1439,1450 ****
  191.       {
  192.   #if YYDEBUG
  193.           if (yydebug)
  194. !             printf("yydebug: state %d, shifting to state %d\n",
  195.                       yystate, yytable[yyn]);
  196.   #endif
  197.           if (yyssp >= yyss + yystacksize - 1)
  198.           {
  199. !             goto yyoverflow;
  200.           }
  201.           *++yyssp = yystate = yytable[yyn];
  202.           *++yyvsp = yylval;
  203. --- 1422,1447 ----
  204.       {
  205.   #if YYDEBUG
  206.           if (yydebug)
  207. !             fprintf(stderr, "yydebug: state %d, shifting to state %d\n",
  208.                       yystate, yytable[yyn]);
  209.   #endif
  210.           if (yyssp >= yyss + yystacksize - 1)
  211.           {
  212. !         /*
  213. !         ** reallocate and recover.  Note that pointers
  214. !         ** have to be reset, or bad things will happen
  215. !         */
  216. !         int yyps_index = (yyssp - yyss);
  217. !         int yypv_index = (yyvsp - yyvs);
  218. !         yystacksize += YYSTACKSIZE;
  219. !         ysave->yyvs = yyvs =
  220. !         (YYSTYPE*)realloc((char*)yyvs,yystacksize * sizeof(YYSTYPE));
  221. !         ysave->yyss = yyss =
  222. !         (short*)realloc((char*)yyss,yystacksize * sizeof(short));
  223. !         if (!yyvs || !yyss)
  224. !         goto yyoverflow;
  225. !         yyssp = yyss + yyps_index;
  226. !         yyvsp = yyvs + yypv_index;
  227.           }
  228.           *++yyssp = yystate = yytable[yyn];
  229.           *++yyvsp = yylval;
  230. ***************
  231. *** 1480,1491 ****
  232.               {
  233.   #if YYDEBUG
  234.                   if (yydebug)
  235. !                     printf("yydebug: state %d, error recovery shifting\
  236. !  to state %d\n", *yyssp, yytable[yyn]);
  237.   #endif
  238.                   if (yyssp >= yyss + yystacksize - 1)
  239.                   {
  240. !                     goto yyoverflow;
  241.                   }
  242.                   *++yyssp = yystate = yytable[yyn];
  243.                   *++yyvsp = yylval;
  244. --- 1477,1503 ----
  245.               {
  246.   #if YYDEBUG
  247.                   if (yydebug)
  248. !                     fprintf(stderr,
  249. !              "yydebug: state %d, error recovery shifting to state %d\n",
  250. !              *yyssp, yytable[yyn]);
  251.   #endif
  252.                   if (yyssp >= yyss + yystacksize - 1)
  253.                   {
  254. !             /*
  255. !             ** reallocate and recover.  Note that pointers
  256. !             ** have to be reset, or bad things will happen
  257. !             */
  258. !             int yyps_index = (yyssp - yyss);
  259. !             int yypv_index = (yyvsp - yyvs);
  260. !             yystacksize += YYSTACKSIZE;
  261. !             ysave->yyvs = yyvs = (YYSTYPE*)realloc((char*)yyvs,
  262. !             yystacksize * sizeof(YYSTYPE));
  263. !             ysave->yyss = yyss = (short*)realloc((char*)yyss,
  264. !             yystacksize * sizeof(short));
  265. !             if (!yyvs || !yyss)
  266. !             goto yyoverflow;
  267. !             yyssp = yyss + yyps_index;
  268. !             yyvsp = yyvs + yypv_index;
  269.                   }
  270.                   *++yyssp = yystate = yytable[yyn];
  271.                   *++yyvsp = yylval;
  272. ***************
  273. *** 1495,1502 ****
  274.               {
  275.   #if YYDEBUG
  276.                   if (yydebug)
  277. !                     printf("yydebug: error recovery discarding state %d\n",
  278. !                             *yyssp);
  279.   #endif
  280.                   if (yyssp <= yyss) goto yyabort;
  281.                   --yyssp;
  282. --- 1507,1515 ----
  283.               {
  284.   #if YYDEBUG
  285.                   if (yydebug)
  286. !                     fprintf(stderr,
  287. !             "yydebug: error recovery discarding state %d\n",
  288. !             *yyssp);
  289.   #endif
  290.                   if (yyssp <= yyss) goto yyabort;
  291.                   --yyssp;
  292. ***************
  293. *** 1513,1520 ****
  294.               yys = 0;
  295.               if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  296.               if (!yys) yys = "illegal-symbol";
  297. !             printf("yydebug: state %d, error recovery discards token %d (%s)\n",
  298. !                     yystate, yychar, yys);
  299.           }
  300.   #endif
  301.           yychar = (-1);
  302. --- 1526,1534 ----
  303.               yys = 0;
  304.               if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  305.               if (!yys) yys = "illegal-symbol";
  306. !             fprintf(stderr,
  307. !         "yydebug: state %d, error recovery discards token %d (%s)\n",
  308. !         yystate, yychar, yys);
  309.           }
  310.   #endif
  311.           yychar = (-1);
  312. ***************
  313. *** 1523,1529 ****
  314.   yyreduce:
  315.   #if YYDEBUG
  316.       if (yydebug)
  317. !         printf("yydebug: state %d, reducing by rule %d (%s)\n",
  318.                   yystate, yyn, yyrule[yyn]);
  319.   #endif
  320.       yym = yylen[yyn];
  321. --- 1537,1543 ----
  322.   yyreduce:
  323.   #if YYDEBUG
  324.       if (yydebug)
  325. !         fprintf(stderr, "yydebug: state %d, reducing by rule %d (%s)\n",
  326.                   yystate, yyn, yyrule[yyn]);
  327.   #endif
  328.       yym = yylen[yyn];
  329. ***************
  330. *** 2242,2249 ****
  331.       {
  332.   #if YYDEBUG
  333.           if (yydebug)
  334. !             printf("yydebug: after reduction, shifting from state 0 to\
  335. !  state %d\n", YYFINAL);
  336.   #endif
  337.           yystate = YYFINAL;
  338.           *++yyssp = YYFINAL;
  339. --- 2256,2264 ----
  340.       {
  341.   #if YYDEBUG
  342.           if (yydebug)
  343. !             fprintf(stderr,
  344. !         "yydebug: after reduction, shifting from state 0 to state %d\n",
  345. !         YYFINAL);
  346.   #endif
  347.           yystate = YYFINAL;
  348.           *++yyssp = YYFINAL;
  349. ***************
  350. *** 2257,2263 ****
  351.                   yys = 0;
  352.                   if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  353.                   if (!yys) yys = "illegal-symbol";
  354. !                 printf("yydebug: state %d, reading %d (%s)\n",
  355.                           YYFINAL, yychar, yys);
  356.               }
  357.   #endif
  358. --- 2272,2278 ----
  359.                   yys = 0;
  360.                   if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  361.                   if (!yys) yys = "illegal-symbol";
  362. !                 fprintf(stderr, "yydebug: state %d, reading %d (%s)\n",
  363.                           YYFINAL, yychar, yys);
  364.               }
  365.   #endif
  366. ***************
  367. *** 2272,2291 ****
  368.           yystate = yydgoto[yym];
  369.   #if YYDEBUG
  370.       if (yydebug)
  371. !         printf("yydebug: after reduction, shifting from state %d \
  372. ! to state %d\n", *yyssp, yystate);
  373.   #endif
  374.       if (yyssp >= yyss + yystacksize - 1)
  375.       {
  376. !         goto yyoverflow;
  377.       }
  378.       *++yyssp = yystate;
  379.       *++yyvsp = yyval;
  380.       goto yyloop;
  381.   yyoverflow:
  382. !     yyerror("yacc stack overflow");
  383.   yyabort:
  384. !     return (1);
  385.   yyaccept:
  386. !     return (0);
  387.   }
  388. --- 2287,2321 ----
  389.           yystate = yydgoto[yym];
  390.   #if YYDEBUG
  391.       if (yydebug)
  392. !         fprintf(stderr,
  393. !         "yydebug: after reduction, shifting from state %d to state %d\n",
  394. !         *yyssp, yystate);
  395.   #endif
  396.       if (yyssp >= yyss + yystacksize - 1)
  397.       {
  398. !     /*
  399. !     ** reallocate and recover.  Note that pointers
  400. !     ** have to be reset, or bad things will happen
  401. !     */
  402. !     int yyps_index = (yyssp - yyss);
  403. !     int yypv_index = (yyvsp - yyvs);
  404. !     yystacksize += YYSTACKSIZE;
  405. !     ysave->yyvs = yyvs =
  406. !         (YYSTYPE*)realloc((char*)yyvs,yystacksize * sizeof(YYSTYPE));
  407. !     ysave->yyss = yyss =
  408. !         (short*)realloc((char*)yyss,yystacksize * sizeof(short));
  409. !     if (!yyvs || !yyss)
  410. !         goto yyoverflow;
  411. !     yyssp = yyss + yyps_index;
  412. !     yyvsp = yyvs + yypv_index;
  413.       }
  414.       *++yyssp = yystate;
  415.       *++yyvsp = yyval;
  416.       goto yyloop;
  417.   yyoverflow:
  418. !     yyerror("Out of memory for yacc stack");
  419.   yyabort:
  420. !     retval = 1;
  421.   yyaccept:
  422. !     return retval;
  423.   }
  424.